// API服务 - 处理与Moonshot API的通信

class ApiService {
  constructor() {
    this.apiUrl = null;
    this.apiKey = null;
    this._initialized = false;
    console.log('ApiService 实例已创建');
  }

  // 加载API配置
  async loadConfig() {
    try {
      if (this._initialized) {
        console.log('API配置已初始化，正在重新加载...');
        this._initialized = false;
      }

      console.log('正在加载API配置...');
      const config = await chrome.storage.sync.get({
        apiUrl: 'https://api.moonshot.cn/v1',
        apiKey: ''
      });
      
      // 验证URL格式
      try {
        if (config.apiUrl && config.apiUrl !== 'https://api.moonshot.cn/v1') {
          new URL(config.apiUrl);
        }
      } catch (e) {
        console.error('API地址格式无效:', config.apiUrl);
        throw new Error('API地址格式无效，请检查设置');
      }

      this.apiUrl = config.apiUrl;
      this.apiKey = config.apiKey;
      
      // 验证配置完整性
      if (!this.apiUrl || !this.apiKey) {
        console.error('API配置不完整:', {
          hasUrl: !!this.apiUrl,
          hasKey: !!this.apiKey
        });
        throw new Error('API配置不完整，请在设置中填写API地址和Key');
      }

      this._initialized = true;
      console.log('API配置加载完成:', {
        apiUrl: this.apiUrl,
        hasKey: !!this.apiKey,
        keyLength: this.apiKey ? this.apiKey.length : 0,
        isInitialized: this._initialized
      });
    } catch (error) {
      this._initialized = false;
      this.apiUrl = null;
      this.apiKey = null;
      console.error('加载API配置失败:', error);
      throw new Error('加载API配置失败: ' + error.message);
    }
  }

  // 检查API配置
  async checkConfig() {
    console.log('检查API配置状态:', {
      isInitialized: this._initialized,
      hasUrl: !!this.apiUrl,
      hasKey: !!this.apiKey
    });

    if (!this._initialized || !this.apiUrl || !this.apiKey) {
      console.log('配置未初始化或不完整，尝试重新加载...');
      await this.loadConfig();
    }

    if (!this.apiUrl || !this.apiKey) {
      console.error('API配置无效:', {
        hasUrl: !!this.apiUrl,
        hasKey: !!this.apiKey
      });
      throw new Error('请先在设置中配置API地址和API Key');
    }
  }

  // 翻译文本
  async translateText(text, targetLang) {
    try {
      console.log('准备翻译文本:', {
        textLength: text.length,
        targetLang
      });

      // 确保配置已加载并检查
      await this.checkConfig();

      // 构建请求数据 - 使用 chat/completions 接口
      const messages = [
        {
          role: "system",
          content: `你是一个翻译助手。请将用户的文本翻译成${targetLang}，只返回翻译后的文本，不要添加任何解释或额外内容。`
        },
        {
          role: "user",
          content: text
        }
      ];

      const requestData = {
        model: "moonshot-v1-8k",
        messages: messages,
        temperature: 0.3,
        // 设置合理的 max_tokens 值，避免截断
        max_tokens: Math.min(text.length * 2, 4000)
      };

      console.log('发送翻译请求:', {
        url: `${this.apiUrl}/chat/completions`,
        method: 'POST',
        data: requestData
      });

      const response = await fetch(`${this.apiUrl}/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.apiKey}`
        },
        body: JSON.stringify(requestData)
      });

      console.log('收到响应:', {
        status: response.status,
        statusText: response.statusText,
        contentType: response.headers.get('content-type')
      });

      // 获取响应文本
      const responseText = await response.text();
      console.log('原始响应内容:', responseText.substring(0, 100));

      // 如果响应状态不是200，处理错误
      if (!response.ok) {
        let errorMessage = '翻译请求失败';
        try {
          const errorData = JSON.parse(responseText);
          errorMessage = errorData.error?.message || errorData.error?.type || errorMessage;
        } catch (e) {
          console.error('解析错误响应失败:', e);
        }
        throw new Error(errorMessage);
      }

      // 解析响应JSON
      let data;
      try {
        data = JSON.parse(responseText);
      } catch (e) {
        console.error('解析响应JSON失败:', e);
        throw new Error('服务器返回的数据格式无效');
      }

      // 验证响应格式
      if (!data.choices || !data.choices[0]?.message?.content) {
        console.error('响应数据格式无效:', data);
        throw new Error('翻译结果格式无效');
      }

      const translatedText = data.choices[0].message.content.trim();
      console.log('翻译成功:', {
        originalLength: text.length,
        translatedLength: translatedText.length,
        resultSample: translatedText.substring(0, 50) + '...'
      });

      return translatedText;

    } catch (error) {
      console.error('翻译过程出错:', error);
      
      // 处理特定错误类型
      if (error.message.includes('content_filter')) {
        throw new Error('翻译内容包含敏感信息，请修改后重试');
      }
      if (error.message.includes('invalid_request_error')) {
        throw new Error('请求格式无效，请检查输入内容');
      }
      if (error.message.includes('invalid_authentication_error')) {
        throw new Error('API密钥无效，请检查设置');
      }
      if (error.message.includes('exceeded_current_quota_error')) {
        throw new Error('账户余额不足，请检查账户状态');
      }
      if (error.message.includes('Failed to fetch')) {
        throw new Error('无法连接到服务器，请检查网络连接');
      }
      
      throw new Error(`翻译失败: ${error.message}`);
    }
  }

  // 总结文本
  async summarizeText(text) {
    try {
      console.log('准备总结文本:', {
        textLength: text.length
      });

      // 确保配置已加载并检查
      await this.checkConfig();

      // 构建请求数据
      const messages = [
        {
          role: "system",
          content: "你是一个文本总结助手。请简洁地总结用户提供的文本，突出关键信息。"
        },
        {
          role: "user",
          content: `请总结以下文本：\n${text}`
        }
      ];

      const requestData = {
        model: "moonshot-v1-8k",
        messages: messages,
        temperature: 0.3,
        max_tokens: Math.min(text.length, 2000)
      };

      console.log('发送总结请求...');
      const response = await fetch(`${this.apiUrl}/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.apiKey}`
        },
        body: JSON.stringify(requestData)
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error?.message || '总结请求失败');
      }

      const data = await response.json();
      const summary = data.choices[0].message.content.trim();
      console.log('总结成功');
      return summary;
    } catch (error) {
      console.error('总结过程出错:', error);
      throw new Error(`总结失败: ${error.message}`);
    }
  }
}

// 导出API服务实例
const apiService = new ApiService();
export default apiService; 